home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 3_0 / PICTXCMD / XCMD.C < prev   
C/C++ Source or Header  |  1988-03-12  |  12KB  |  482 lines
  1. #include "HyperXCMD.h"
  2.  
  3.  /*
  4.      Convert a boolean to 'true' or 'false'.  Instead of returning 
  5.     a new string, as Pascal does, it expects you to create mystr
  6.     and pass it in to be filled.
  7. */
  8. pascal void
  9. BoolToStr(paramPtr,bool,mystr)
  10. register XCmdBlockPtr    paramPtr;
  11. Boolean                    bool;
  12. Str31                    mystr;
  13. {
  14.     paramPtr->inArgs[0] = (long)bool;
  15.     paramPtr->inArgs[1] = (long)mystr;
  16.     paramPtr->request = xreqBoolToStr;
  17.     (*paramPtr->entryPoint)();
  18. }
  19.  
  20. /*
  21.     Evaluate a HyperCard expression and return the answer.  The answer is
  22.    a handle to a zero-terminated string.
  23. */
  24. pascal Handle
  25. EvalExpr(paramPtr,expr)
  26. register XCmdBlockPtr    paramPtr;
  27. StringPtr    expr;
  28. {
  29.     paramPtr->inArgs[0] = (long)expr;
  30.     paramPtr->request = xreqEvalExpr;
  31.     (*paramPtr->entryPoint)();
  32.     return (Handle)paramPtr->outArgs[0];
  33. }
  34.  
  35. /*
  36.     Original comment:
  37.     Convert an extended long integer to decimal digits in a string.  
  38.     Instead of returning a new string, as Pascal does, it expects 
  39.     you to create mystr and pass it in to be filled.
  40. */
  41.     
  42. /*
  43.     My comment:
  44.     I assume that an extended is supposed to be an 80-byte double,
  45.     which is declared as double in LSC.  I've changed "extended" to
  46.     "double" to reflect this
  47. */
  48. pascal void
  49. ExtToStr(paramPtr,myext,mystr)
  50. register XCmdBlockPtr    paramPtr;
  51. double         *    myext;
  52. Str31    mystr;
  53. {
  54.     paramPtr->inArgs[0] = (long)myext;
  55.     paramPtr->inArgs[1] = (long)mystr;
  56.     paramPtr->request = xreqExtToStr;
  57.     (*paramPtr->entryPoint)();
  58. }
  59.  
  60. /*
  61.     Return a handle to a zero-terminated string containing the value of 
  62.     the field whise ID is fieldID.  You must dispose of the handle.
  63. */
  64. pascal Handle
  65. GetFieldByID(paramPtr,cardFieldFlag,fieldID)
  66. register XCmdBlockPtr    paramPtr;
  67. Boolean    cardFieldFlag;
  68. short    fieldID;
  69. {
  70.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  71.     paramPtr->inArgs[1] = fieldID;
  72.     paramPtr->request = xreqGetFieldByID;
  73.     (*paramPtr->entryPoint)();
  74.     return (Handle)paramPtr->outArgs[0];
  75. }
  76.  
  77. /*
  78.     Return a handle to a zero-terminated string containing the value of 
  79.     field fieldName on the current card.  You must dispose the handle.
  80. */
  81. pascal Handle
  82. GetFieldByName(paramPtr,cardFieldFlag,fieldName)
  83. register XCmdBlockPtr    paramPtr;
  84. Boolean    cardFieldFlag;
  85. StringPtr    fieldName;
  86. {
  87.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  88.     paramPtr->inArgs[1] = (long)fieldName;
  89.     paramPtr->request = xreqGetFieldByName;
  90.     (*paramPtr->entryPoint)();
  91.     return (Handle)paramPtr->outArgs[0];
  92. }
  93.  
  94. /*
  95.     Return a handle to a zero-terminated string containing the value of 
  96.     field fieldNum on the current card.  You must dispose of the handle.
  97. */
  98. pascal Handle
  99. GetFieldByNum(paramPtr, cardFieldFlag,fieldNum)
  100. register XCmdBlockPtr    paramPtr;
  101. Boolean    cardFieldFlag;
  102. short    fieldNum;
  103. {
  104.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  105.     paramPtr->inArgs[1] = fieldNum;
  106.     paramPtr->request = xreqGetFieldByNum;
  107.     (*paramPtr->entryPoint)();
  108.     return (Handle)paramPtr->outArgs[0];
  109. }
  110.  
  111. /*
  112.     Return a handle to a zero-terminated string containing the value of 
  113.     the specified HyperTalk global variable.
  114. */
  115. pascal Handle
  116. GetGlobal(paramPtr,globName)
  117. register XCmdBlockPtr    paramPtr;
  118. StringPtr    globName;
  119. {
  120.     paramPtr->inArgs[0] = (long)globName;
  121.     paramPtr->request = xreqGetGlobal;
  122.     (*paramPtr->entryPoint)();
  123.     return (Handle)paramPtr->outArgs[0];
  124. }
  125.  
  126. /*
  127.     Convert an unsigned long integer to a Pascal string.  Instead of 
  128.     returning a new string, as Pascal does, it expects you to 
  129.     create mystr and pass it in to be filled.
  130. */
  131. pascal void
  132. LongToStr(paramPtr, posNum, mystr)
  133. register XCmdBlockPtr    paramPtr;
  134. long             posNum;
  135. Str31    mystr;
  136. {
  137.     paramPtr->inArgs[0] = posNum;
  138.     paramPtr->inArgs[1] = (long)mystr;
  139.     paramPtr->request = xreqLongToStr;
  140.     (*paramPtr->entryPoint)();
  141. }
  142.  
  143.  
  144. /*
  145.     Convert an unsigned long integer to a hexadecimal number and put it
  146.     into a Pascal string.  Instead of returning a new string, as Pascal
  147.     does, it expects you to create mystr and pass it in to be filled.
  148. */
  149. pascal void
  150. NumToHex(paramPtr, num, nDigits, mystr)
  151. register XCmdBlockPtr    paramPtr;
  152. long             num;
  153. short            nDigits;
  154. Str31    mystr;
  155. {
  156.     paramPtr->inArgs[0] = num;
  157.     paramPtr->inArgs[1] = nDigits;
  158.     paramPtr->inArgs[2] = (long)mystr;
  159.     paramPtr->request = xreqNumToHex;
  160.     (*paramPtr->entryPoint)();
  161. }
  162.  
  163. /*
  164.     Convert a signed long integer to a Pascal string.  Instead of 
  165.     returning a new string, as Pascal does, it expects you to 
  166.     create mystr and pass it in to be filled.
  167. */
  168. pascal void
  169. NumToStr(paramPtr,num,mystr)
  170. register XCmdBlockPtr    paramPtr;
  171. long             num;
  172. Str31    mystr;
  173. {
  174.     paramPtr->inArgs[0] = num;
  175.     paramPtr->inArgs[1] = (long)mystr;
  176.     paramPtr->request = xreqNumToStr;
  177.     (*paramPtr->entryPoint)();
  178. }
  179.  
  180. /*
  181.     Convert a Pascal string to a zero-terminated string.  Returns a handle
  182.     to a new zero-terminated string.  The caller must dispose the handle.
  183.     You'll need to do this for any result or argument you send from 
  184.     your XCMD to HyperTalk.  Note that if you use C-format strings,
  185.     you won't need to do this from C.
  186. */
  187. pascal Handle
  188. PasToZero(paramPtr,pasStr)
  189. register XCmdBlockPtr    paramPtr;
  190. StringPtr    pasStr;
  191. {
  192.     paramPtr->inArgs[0] = (long)pasStr;
  193.     paramPtr->request = xreqPasToZero;
  194.     (*paramPtr->entryPoint)();
  195.     return (Handle)paramPtr->outArgs[0];
  196. }
  197.  
  198. /*
  199.     zeroStr points into a zero-terminated string.  Collect the 
  200.     characters from there to the next carriage Return and return 
  201.     them in the Pascal string pasStr.  If a Return is not found, 
  202.     collect chars until the end of the string.
  203. */
  204. pascal void
  205. ReturnToPas(paramPtr,zeroStr,pasStr)
  206. register XCmdBlockPtr    paramPtr;
  207. Ptr    zeroStr;
  208. StringPtr    pasStr;
  209. {
  210.     paramPtr->inArgs[0] = (long)zeroStr;
  211.     paramPtr->inArgs[1] = (long)pasStr;
  212.     paramPtr->request = xreqReturnToPas;
  213.     (*paramPtr->entryPoint)();
  214. }
  215.  
  216. /*
  217.     Move the pointer scanPtr along a zero-terminated 
  218.     string until it points at a Return character
  219.     or a zero byte.
  220. */
  221. pascal void
  222. ScanToReturn(paramPtr,scanHndl)
  223. register XCmdBlockPtr    paramPtr;
  224. Ptr *    scanHndl;
  225. {
  226.     paramPtr->inArgs[0] = (long)scanHndl;
  227.     paramPtr->request = xreqScanToReturn;
  228.     (*paramPtr->entryPoint)();
  229. }
  230.  
  231. /*
  232.     Move the pointer scanPtr along a zero-terminated 
  233.     string until it points at a zero byte.
  234. */
  235. pascal void
  236. ScanToZero(paramPtr,scanHndl)
  237. register XCmdBlockPtr    paramPtr;
  238. Ptr *    scanHndl;
  239. {
  240.     paramPtr->inArgs[0] = (long)scanHndl;
  241.     paramPtr->request = xreqScanToZero;
  242.     (*paramPtr->entryPoint)();
  243. }
  244.  
  245. /*
  246.     Send a HyperCard message (a command with arguments) to the current card.
  247.     msg is a pointer to a Pascal-format string.
  248. */
  249. pascal void
  250. SendCardMessage(paramPtr, msg)
  251. register XCmdBlockPtr    paramPtr;
  252. StringPtr    msg;
  253. {
  254.     paramPtr->inArgs[0] = (long)msg;
  255.     paramPtr->request = xreqSendCardMessage;
  256.     (*paramPtr->entryPoint)();
  257. }
  258.  
  259. /*
  260.     Set the value of the field whose ID is fieldID to be the zero-
  261.     terminated string in fieldVal.  The contents of the Handle are 
  262.     copied, so you must still dispose it afterwards.
  263. */
  264. pascal void
  265. SetFieldByID(paramPtr,cardFieldFlag,fieldID,fieldVal)
  266. register XCmdBlockPtr    paramPtr;
  267. Boolean    cardFieldFlag;
  268. short    fieldID;
  269. Handle    fieldVal;
  270. {
  271.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  272.     paramPtr->inArgs[1] = fieldID;
  273.     paramPtr->inArgs[2] = (long)fieldVal;
  274.     paramPtr->request = xreqSetFieldByID;
  275.     (*paramPtr->entryPoint)();
  276. }
  277.  
  278. /*
  279.     Set the value of field fieldName to be the zero-terminated string 
  280.     in fieldVal.  The contents of the Handle are copied, so you must 
  281.     still dispose it afterwards.
  282. */
  283. pascal void
  284. SetFieldByName(paramPtr,cardFieldFlag,fieldName,fieldVal)
  285. register XCmdBlockPtr    paramPtr;
  286. Boolean    cardFieldFlag;
  287. StringPtr    fieldName;
  288. Handle    fieldVal;
  289. {
  290.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  291.     paramPtr->inArgs[1] = (long)fieldName;
  292.     paramPtr->inArgs[2] = (long)fieldVal;
  293.     paramPtr->request = xreqSetFieldByName;
  294.     (*paramPtr->entryPoint)();
  295. }
  296.  
  297. /*
  298.     Set the value of field fieldNum to be the zero-terminated string 
  299.     in fieldVal.  The contents of the Handle are copied, so you must 
  300.     still dispose it afterwards.
  301. */
  302. pascal void
  303. SetFieldByNum(paramPtr,cardFieldFlag,fieldNum,fieldVal)
  304. register XCmdBlockPtr    paramPtr;
  305. Boolean    cardFieldFlag;
  306. short    fieldNum;
  307. Handle    fieldVal;
  308. {
  309.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  310.     paramPtr->inArgs[1] = fieldNum;
  311.     paramPtr->inArgs[2] = (long)fieldVal;
  312.     paramPtr->request = xreqSetFieldByNum;
  313.     (*paramPtr->entryPoint)();
  314. }
  315.  
  316. /*
  317.     Set the value of the specified HyperTalk global variable to be
  318.     the zero-terminated string in globValue.  The contents of the 
  319.     Handle are copied, so you must still dispose it afterwards.
  320. */
  321. pascal void
  322. SetGlobal(paramPtr,globName,globValue)
  323. register XCmdBlockPtr    paramPtr;
  324. StringPtr    globName;
  325. Handle    globValue;
  326. {
  327.     paramPtr->inArgs[0] = (long)globName;
  328.     paramPtr->inArgs[1] = (long)globValue;
  329.     paramPtr->request = xreqSetGlobal;
  330.     (*paramPtr->entryPoint)();
  331. }
  332.  
  333. /*
  334.     Return true if the two strings have the same characters.  
  335.     Case insensitive compare of the strings.
  336. */
  337. pascal Boolean
  338. StringEqual(paramPtr,str1,str2)
  339. register XCmdBlockPtr    paramPtr;
  340. unsigned char * str1;
  341. unsigned char * str2;
  342. {
  343.     paramPtr->inArgs[0] = (long)str1;
  344.     paramPtr->inArgs[1] = (long)str2;
  345.     paramPtr->request = xreqStringEqual;
  346.     (*paramPtr->entryPoint)();
  347.     return (Boolean)paramPtr->outArgs[0];
  348. }
  349.  
  350. /*
  351.     Count the characters from where strPtr points until the next zero byte. 
  352.     Does not count the zero itself.  strPtr must be a zero-terminated string.
  353. */
  354. pascal long
  355. StringLength(paramPtr,strPtr)
  356. register XCmdBlockPtr    paramPtr;
  357. StringPtr    strPtr;
  358. {
  359.     paramPtr->inArgs[0] = (long)strPtr;
  360.     paramPtr->request = xreqStringLength;
  361.     (*paramPtr->entryPoint)();
  362.     return paramPtr->outArgs[0];
  363. }
  364.  
  365. /*
  366.     Perform case-insensitive match looking for pattern anywhere in
  367.     target, returning a pointer to first character of the first match,
  368.     in target or NIL if no match found.  pattern is a Pascal string,
  369.     and target is a zero-terminated string.
  370. */
  371. pascal Ptr
  372. StringMatch(paramPtr, pattern, target)
  373. register XCmdBlockPtr    paramPtr;
  374. StringPtr    pattern;
  375. Ptr    target;
  376. {
  377.     paramPtr->inArgs[0] = (long)pattern;
  378.     paramPtr->inArgs[1] = (long)target;
  379.     paramPtr->request = xreqStringMatch;
  380.     (*paramPtr->entryPoint)();
  381.     return (Ptr)paramPtr->outArgs[0];
  382. }
  383.  
  384. /*
  385.     Convert the Pascal strings 'true' and 'false' to booleans.
  386. */
  387. pascal Boolean
  388. StrToBool(paramPtr,str)
  389. register XCmdBlockPtr    paramPtr;
  390. Str31     str;
  391. {
  392.     paramPtr->inArgs[0] = (long)str;
  393.     paramPtr->request = xreqStrToBool;
  394.     (*paramPtr->entryPoint)();
  395.     return (Boolean)paramPtr->outArgs[0];
  396. }
  397.  
  398. /*
  399.     Original comment:
  400.     Convert a string of ASCII decimal digits to an extended long integer.
  401.     Instead of returning a new extended, as Pascal does, it expects you 
  402.     to create myext and pass it in to be filled.
  403. */
  404.  
  405. /*
  406.     My comment:  extended, as far as I know, is an 80-bit double, not a
  407.     long integer.  Since LSC doubles are 80-bit, I've changed myext to
  408.     a pointer to a double.
  409. */
  410. pascal void StrToExt(paramPtr, str, myext)
  411. register XCmdBlockPtr paramPtr;
  412. Str31     str;
  413. double *    myext;
  414. {
  415.     paramPtr->inArgs[0] = (long)str;
  416.     paramPtr->inArgs[1] = (long)myext;
  417.     paramPtr->request = xreqStrToExt;
  418.     (*paramPtr->entryPoint)();
  419. }
  420.  
  421. /*
  422.     Convert a string of ASCII decimal digits to an unsigned long integer.
  423. */
  424. pascal long
  425. StrToLong(paramPtr, strPtr)
  426. register XCmdBlockPtr    paramPtr;
  427. Str31    strPtr;
  428. {
  429.     paramPtr->inArgs[0] = (long)strPtr;
  430.     paramPtr->request = xreqStrToLong;
  431.     (*paramPtr->entryPoint)();
  432.     return (long)paramPtr->outArgs[0];
  433. }
  434.  
  435. /*
  436.     Convert a string of ASCII decimal digits to a signed long integer.
  437.     Negative sign is allowed.
  438. */
  439. pascal long
  440. StrToNum(paramPtr, str)
  441. register XCmdBlockPtr    paramPtr;
  442. Str31     str;
  443. {
  444.     paramPtr->inArgs[0] = (long)str;
  445.     paramPtr->request = xreqStrToNum;
  446.     (*paramPtr->entryPoint)();
  447.     return paramPtr->outArgs[0];
  448. }
  449.  
  450. /*
  451.     Write zeros into memory starting at destPtr and going for longCount 
  452.     number of bytes.
  453. */
  454. pascal void
  455. ZeroBytes(paramPtr, dstPtr, longCount)
  456. register XCmdBlockPtr    paramPtr;
  457. Ptr    dstPtr;
  458. long    longCount;
  459. {
  460.     paramPtr->inArgs[0] = (long)dstPtr;
  461.     paramPtr->inArgs[1] = longCount;
  462.     paramPtr->request = xreqZeroBytes;
  463.     (*paramPtr->entryPoint)();
  464. }
  465.  
  466. /*
  467.     Fill the Pascal string with the contents of the zero-terminated
  468.     string.  Useful for converting the arguments of any XCMD to 
  469.     Pascal strings.
  470. */
  471. pascal void
  472. ZeroToPas(paramPtr,zeroStr,pasStr)
  473. register XCmdBlockPtr    paramPtr;
  474. unsigned char    *zeroStr;
  475. StringPtr        pasStr;
  476. {
  477.     paramPtr->inArgs[0] = (long)zeroStr;
  478.     paramPtr->inArgs[1] = (long)pasStr;
  479.     paramPtr->request = xreqZeroToPas;
  480.     (*paramPtr->entryPoint)();
  481. }
  482.